home *** CD-ROM | disk | FTP | other *** search
/ PCMania 64 / PCMania CD64_1.iso / phy / phy005 / oop / cadena.cpp next >
C/C++ Source or Header  |  1997-06-23  |  8KB  |  314 lines
  1. ///////////////////////////////////////
  2. // Implementación de la classe "Cadena"
  3. //   Navi Dj / PhyMosys
  4. ///////////////////////////////////////
  5.  
  6. #include "cadena.hpp"
  7.  
  8. //  Constructor: inicializa las variables.
  9. Cadena :: Cadena(void)
  10. {
  11.  longi=5;
  12.  reset();
  13.  if(!(contenido=new char[LONG_TIPICA]))
  14.    _error=2;
  15.  strcpy(contenido, "Vacio");    //  El texto se puede cambiar.
  16.  }
  17.  
  18. //  Constructor 2: Otro más...
  19. Cadena :: Cadena(const Cadena &cad)
  20. {
  21.  reset();
  22.  longi=strlen(cad.contenido);
  23.  if(!(contenido=new char[longi+1]))
  24.    _error=2;
  25.  strcpy(contenido, cad.contenido);
  26.  }
  27.  
  28. //  Constructor 3: inicializa con más precisión las variables.
  29. Cadena :: Cadena(const char *str)
  30. {
  31.  reset();
  32.  longi=strlen(str);
  33.  if(!(contenido=new char[longi+1]))
  34.    _error=2;
  35.  strcpy(contenido, str);
  36.  }
  37.  
  38. //  Constructor 4: inicializa concatenando 2 arrays de caracteres.
  39. Cadena :: Cadena(const char *str, const char *str2)
  40. {
  41.  reset();
  42.  longi=strlen(str)+strlen(str2);
  43.  if(!(contenido=new char[longi+1]))
  44.    _error=2;
  45.  strcpy(contenido, str);
  46.  strcat(contenido, str2);
  47.  }
  48.  
  49. //  Constructor 5: inicializa concatenando 2 cadenas.
  50. Cadena :: Cadena(const Cadena &str, const Cadena &str2)
  51. {
  52.  reset();
  53.  longi=strlen(str.contenido)+strlen(str2.contenido);
  54.  if(!(contenido=new char[longi+1]))
  55.    _error=2;
  56.  strcpy(contenido, str.contenido);
  57.  strcat(contenido, str2.contenido);
  58.  }
  59.  
  60. //  Destructor: devuelve la memoria al sistema.
  61. Cadena :: ~Cadena()
  62. {
  63.  delete contenido;
  64.  }
  65.  
  66. //  Anyade: concatena dos cadenas.
  67. void Cadena :: anyade(const Cadena &str)
  68. {
  69.  char *Cad;
  70.  if(!(Cad=new char[strlen(this->contenido)+strlen(str.contenido)+1]))
  71.    _error=2;
  72.  strcpy(Cad, this->contenido);
  73.  strcat(Cad, str.contenido);
  74.  delete this->contenido;
  75.  longi=strlen(Cad);
  76.  if(!(contenido=new char[longi+1]))
  77.    _error=2;
  78.  strcpy(this->contenido, Cad);
  79.  delete Cad;
  80.  }
  81.  
  82. //  Anyade: concatena 2 cadenas directament.
  83. void Cadena :: anyade(const char *str)
  84. {
  85.  char *Cad;
  86.  if(!(Cad=new char[strlen(this->contenido)+strlen(str)+1]))
  87.    _error=2;
  88.  strcpy(Cad, this->contenido);
  89.  strcat(Cad, str);
  90.  delete this->contenido;
  91.  longi=strlen(Cad);
  92.  if(!(contenido=new char[longi+1]))
  93.    _error=2;
  94.  strcpy(this->contenido, Cad);
  95.  delete Cad;       //  Es interesante liberar manualmente la memoria.
  96.  }
  97.  
  98. //  Compo: Compone una cadena (con char *) a partir de otras 2.
  99. void Cadena :: compo(const char *str, const char *str2)
  100. {
  101.  delete contenido;
  102.  longi=strlen(str)+strlen(str2);
  103.  if(!(contenido=new char[longi+1]))
  104.    _error=2;
  105.  strcpy(contenido, str);
  106.  strcat(contenido, str2);
  107.  }
  108.  
  109. //  Compo: Compone una cadena a partir de otras 2.
  110. void Cadena :: compo(const Cadena &str, const char *str2)
  111. {
  112.  compo(str.contenido, str2);
  113.  }
  114.  
  115. //  Compo: Otra variante.
  116. void Cadena :: compo(const Cadena &str, const Cadena &str2)
  117. {
  118.  compo(str.contenido, str2.contenido);
  119.  }
  120.  
  121. //  Compo: Otra variante.
  122. void Cadena :: compo(const char *str, const Cadena &str2)
  123. {
  124.  compo(str, str2.contenido);
  125.  }
  126.  
  127. //  Copia: Hace una cópia literal de la cadena.
  128. void Cadena :: copia(const Cadena &str)
  129. {
  130.  delete contenido;
  131.  longi=str.longi;
  132.  if(!(contenido=new char[str.longi+1]))
  133.    _error=2;
  134.  strcpy(contenido, str.contenido);
  135.  }
  136.  
  137. //  Copia: Hace una cópia literal del tipo predefinido char *.
  138. void Cadena :: copia(const char *str)
  139. {
  140.  delete contenido;
  141.  longi=strlen(str);
  142.  if(!(contenido=new char[longi+1]))
  143.    _error=2;
  144.  strcpy(contenido, str);
  145.  }
  146.  
  147. //  Operador << (surtida): redirige el flujo de salida.
  148. ostream &operator << (ostream &out, const Cadena &str)
  149. {
  150.  out << str.contenido;
  151.  return out;
  152.  }
  153.  
  154. //  Operador >> (entrada): redirige el flujo de entrada.
  155. istream &operator >> (istream &in, Cadena &str)
  156. {
  157.  char cad[MAX_LONG];
  158.  in.getline(cad, MAX_LONG);
  159.  str.longi=strlen(cad);
  160.  delete str.contenido;
  161.  str.contenido=new char[str.longi+1];
  162.  strcpy(str.contenido, cad);
  163.  return in;
  164.  }
  165.  
  166. // num_letras: Devuelve el número de letras en la cadena.
  167. int Cadena :: num_letras(void)
  168. {
  169.  return strlen(contenido);
  170.  }
  171.  
  172. // num_palabras: Devuelve el número de palabras en la cadena.
  173. int Cadena :: num_palabras(void)
  174. {
  175.  int i,j=0;
  176.  for(int num_par=1; j<longi; num_par++)
  177.   {                          //  Fins que acabem una paraula.
  178.    for(i=j; i<longi && contenido[i]!=' '; i++);
  179.    for(j=i; j<longi && contenido[j]==' '; j++);
  180.    }
  181.  return num_par-1;
  182.  }
  183.  
  184. // Letra: Este método devuelve la letra de la posición "index".
  185. char Cadena :: letra(int index)
  186. {
  187.  return contenido[index-1];
  188.  }
  189.  
  190. // Palabra: Devuelve la palabra index-ésima.
  191. Cadena Cadena :: palabra(int index)
  192. {
  193.  char *cad;
  194.  int i, j, num_par;
  195.  if(!(cad=new char[longi]))
  196.    _error=2;
  197.  
  198.  for(num_par=1, j=0; j<longi && num_par<index; num_par++)
  199.   {                             //  Hasta que acabemos una palabra.
  200.    for(i=j; i<longi && contenido[i]!=' '; i++);
  201.    for(j=i; j<longi && contenido[j]==' '; j++);
  202.    }
  203.  if(num_par==index)             //  Si hay suficientes palabras.
  204.   {
  205.    for(i=j; i<longi && contenido[i]!=' '; i++)
  206.      cad[i-j]=contenido[i];
  207.    cad[i-j]='\x0';
  208.    }
  209.   else
  210.    _error=1;
  211.  
  212.  Cadena X(cad);
  213.  delete cad;
  214.  return X;
  215.  }
  216.  
  217. // Igual: Indica si 2 cadenas son iguales.
  218. int Cadena :: igual(const Cadena &str)
  219. {
  220.  return !strcmp(this->contenido, str.contenido);
  221.  }
  222.  
  223. // Igual: Idem anterior para char *.
  224. int Cadena :: igual(const char *str)
  225. {
  226.  return strcmp(this->contenido, str)==0;
  227.  }
  228.  
  229. // Diferentes: Indica si 2 cadenas son diferentes.
  230. int Cadena :: diferentes(const Cadena &str)
  231. {
  232.  return strcmp(this->contenido, str.contenido);
  233.  }
  234.  
  235. // Diferentes: Idem para char *.
  236. int Cadena :: diferentes(const char *str)
  237. {
  238.  return !strcmp(this->contenido, str);
  239.  }
  240.  
  241. // Anterior: Compara alfabéticamente 2 cadenas y dice si 'str' es anterior.
  242. int Cadena :: anterior(const Cadena &str)
  243. {
  244.  int i;
  245.  for(i=0; this->contenido[i]==str.contenido[i]; i++);
  246.  return this->contenido[i]<str.contenido[i];
  247.  }
  248.  
  249. // Anterior: Idem anterior para char *
  250. int Cadena :: anterior(const char *str)
  251. {
  252.  int i;
  253.  for(i=0; this->contenido[i]==str[i]; i++);
  254.  return this->contenido[i]<str[i];
  255.  }
  256.  
  257. // Posterior: Compara alfabéticament 2 cadenes y dice si 'str' es posterior.
  258. int Cadena :: posterior(const Cadena &str)
  259. {
  260.  int i;
  261.  for(i=0; this->contenido[i]==str.contenido[i]; i++);
  262.  return this->contenido[i]>str.contenido[i];
  263.  }
  264.  
  265. // Posterior: Idem anterior para char *
  266. int Cadena :: posterior(const char *str)
  267. {
  268.  int i;
  269.  for(i=0; this->contenido[i]==str[i]; i++);
  270.  return this->contenido[i]>str[i];
  271.  }
  272.  
  273. // Donde: Dice donde se encuentra una subcadena (que palabra es). Devuelve -1
  274. //        si no encontrado.
  275. int Cadena :: donde(const Cadena &str)
  276. {
  277.  return this->donde(str.contenido);
  278.  }
  279.  
  280. // Donde: Idem anterior para char *
  281. int Cadena :: donde(const char *str)
  282. {
  283.  char *ptr;
  284.  int i, j, k, fin;
  285.  
  286.  j=0; fin=1==0;
  287.  while(!fin)
  288.   {
  289.    k=0;
  290.    for(i=j; contenido[i]!=str[0]; i++);    //  Espera la 1ª coincidencia.
  291.    for(j=i; contenido[j]==str[k]; j++)  //  Hasta que hayan diferencias.
  292.      if(k++==strlen(str)-1)
  293.       {
  294.        fin=1==1;
  295.        break;                           //  Tambien acabamos cuando es igual.
  296.        }
  297.    if(j>strlen(contenido)) fin=21;      //  Indicamos error (no encontrada).
  298.    }
  299.  
  300.  int num_par;
  301.  if(fin!=21)
  302.   {
  303.    for(k=0; k<j && contenido[k]==' '; k++);  // Pasamos los espacios en blanco.
  304.    for(num_par=0; k<j; num_par++)
  305.     {                           //  Hasta que acabemos una palabra.
  306.      for(i=k; i<j && contenido[i]!=' '; i++);
  307.      for(k=i; k<j && contenido[k]==' '; k++);
  308.      }
  309.    }
  310.  else
  311.    num_par=-1;
  312.  return num_par;
  313.  }
  314.